home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2004 #2 / Amiga Plus CD - 2004 - No. 02.iso / AmiSoft / Disk / moni / FileX-src.lha / FileX-src / clipconv.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-22  |  19.6 KB  |  957 lines
  1. #include "FileXStructs.h"
  2. #include "FileXStrings.h"
  3. #include "allprotos.h"
  4. #include "WindowInfo.h"
  5.  
  6. enum { CM_BIN = 0, CM_DEC, CM_HEX, CM_OCT, CM_RAW, CM_TEXT };
  7.  
  8. static struct WindowInfo *ClipConvWI;
  9. static struct Window *ClipConvWnd;
  10. static struct Gadget *ClipConvGList;
  11. static struct Gadget *ClipConvGadgets[6];
  12. static long ClipConvLeft = -1, ClipConvTop = -1, ClipConvWidth = -1;
  13.  
  14. static long ClipConvTo, ClipConvFrom;
  15. static char *FromStringDisplay, *ToStringDisplay;
  16.  
  17. static char *CCModeNames[] =
  18. {
  19.     MSG_GADGET_CLIPCONV_CYCLE_BIN,
  20.     MSG_GADGET_CLIPCONV_CYCLE_DEC,
  21.     MSG_GADGET_CLIPCONV_CYCLE_HEX,
  22.     MSG_GADGET_CLIPCONV_CYCLE_OCT,
  23.     MSG_GADGET_CLIPCONV_CYCLE_RAW,
  24.     MSG_GADGET_CLIPCONV_CYCLE_TEXT,
  25.     0
  26. };
  27.  
  28. static Localized = FALSE;
  29.  
  30. static void SetClipConvFromGadget( char *text )
  31. {
  32.     if( FromStringDisplay ) FreeVec( FromStringDisplay );
  33.  
  34.     if( FromStringDisplay = AllocVec( strlen( text ) + 1, MEMF_ANY ))
  35.     {
  36.         strcpy( FromStringDisplay, text );
  37.  
  38.         GT_SetGadgetAttrs( ClipConvGadgets[ 3 ] , ClipConvWnd, NULL,
  39.                                     GTTX_Text, FromStringDisplay,
  40.                                     TAG_DONE);
  41.     }
  42. }
  43.  
  44. static void SetClipConvToGadget( char *text )
  45. {
  46.     if( ToStringDisplay ) FreeVec( ToStringDisplay );
  47.  
  48.     if( ToStringDisplay = AllocVec( strlen( text ) + 1, MEMF_ANY ))
  49.     {
  50.         strcpy( ToStringDisplay, text );
  51.  
  52.         GT_SetGadgetAttrs( ClipConvGadgets[ 4 ] , ClipConvWnd, NULL,
  53.                                     GTTX_Text, ToStringDisplay,
  54.                                     TAG_DONE);
  55.     }
  56. }
  57.  
  58. static BOOL SetClipConvData( char *Daten, LONG Laenge, BOOL SetFrom, BOOL SetRaw, BOOL Convert )
  59. {
  60.     UBYTE *ptr, *ToDaten;
  61.  
  62.     if( ToDaten = ptr = AllocVec( Laenge * 2 + 1, MEMF_ANY ))
  63.     {
  64.         int k;
  65.  
  66.         if( !SetRaw )
  67.         {
  68.             strncpy( ToDaten, Daten, Laenge );
  69.             ToDaten[ Laenge ] = 0;
  70.         }
  71.         else
  72.         {
  73.             for( k = 0; k < Laenge; k++ )
  74.             {
  75.                 *ptr++ = hexarray[( Daten[ k ] >> 4 ) & 0xf ];
  76.                 *ptr++ = hexarray[ Daten[ k ] & 0xf ];
  77.             }
  78.     
  79.             *ptr = 0;
  80.         }
  81.         
  82.         if( SetFrom )
  83.             SetClipConvFromGadget( ToDaten );
  84.         else
  85.             SetClipConvToGadget( ToDaten );
  86.  
  87.         if( Convert )
  88.             SaveClip( ToDaten, Laenge * ( SetRaw ? 2 : 1 ));
  89.  
  90.         FreeVec( ToDaten );
  91.         return( FALSE );
  92.     }
  93.     else
  94.     {
  95.         if( SetFrom )
  96.             SetClipConvFromGadget( GetStr( MSG_INFO_GLOBAL_CANTALLOCSOMEMEM ));
  97.         else
  98.             SetClipConvToGadget( GetStr( MSG_INFO_GLOBAL_CANTALLOCSOMEMEM ));
  99.         return( TRUE );
  100.     }
  101. }
  102.  
  103. static BOOL SetClipConvDataBin( char *Daten, LONG Laenge, BOOL SetFrom, BOOL Convert )
  104. {
  105.     UBYTE *ptr, *ToDaten;
  106.  
  107.     if( ToDaten = ptr = AllocVec( Laenge * 8 + 1, MEMF_ANY ))
  108.     {
  109.         int k, j;
  110.         int Aktu;
  111.  
  112.         for( k = 0; k < Laenge; k++ )
  113.         {
  114.             Aktu = Daten[ k ];
  115.  
  116.             for( j = 0; j < 8; j++ )
  117.             {
  118.                 ptr[ 7 - j ] = ( Aktu & 1 ) + '0';
  119.  
  120.                 Aktu = Aktu >> 1;
  121.             }
  122.  
  123.             ptr += 8;
  124.         }
  125.  
  126.         *ptr = 0;
  127.         
  128.         if( SetFrom )
  129.             SetClipConvFromGadget( ToDaten );
  130.         else
  131.             SetClipConvToGadget( ToDaten );
  132.  
  133.         if( Convert )
  134.             SaveClip( ToDaten, Laenge * 8 );
  135.  
  136.         FreeVec( ToDaten );
  137.         return( FALSE );
  138.     }
  139.     else
  140.     {
  141.         if( SetFrom )
  142.             SetClipConvFromGadget( GetStr( MSG_INFO_GLOBAL_CANTALLOCSOMEMEM ));
  143.         else
  144.             SetClipConvToGadget( GetStr( MSG_INFO_GLOBAL_CANTALLOCSOMEMEM ));
  145.         return( TRUE );
  146.     }
  147. }
  148.  
  149. static BOOL IsDecString( UBYTE *String, LONG Laenge )
  150. {
  151.     UBYTE *ptr = String;
  152.     BOOL Valid = TRUE;
  153.  
  154.     while( ptr < String + Laenge )
  155.         if( !isdigit( *ptr ))
  156.         {
  157.             Valid = FALSE;
  158.             break;
  159.         }
  160.         else
  161.             ptr++;
  162.  
  163.     return( Valid );
  164. }
  165.  
  166. static BOOL IsOctString( UBYTE *String, LONG Laenge )
  167. {
  168.     UBYTE *ptr = String;
  169.     BOOL Valid = TRUE;
  170.  
  171.     while( ptr < String + Laenge )
  172.         if( !(( *ptr >= '0' ) && ( *ptr <= '7' )))
  173.         {
  174.             Valid = FALSE;
  175.             break;
  176.         }
  177.         else
  178.             ptr++;
  179.  
  180.     return( Valid );
  181. }
  182.  
  183. static void UpdateClipConv( BOOL Convert )
  184. {
  185.     BOOL Error = FALSE;
  186.  
  187.     ULONG Laenge;
  188.     UBYTE *String;
  189.  
  190.     if( String = GetClip( &Laenge ) )
  191.     {
  192.         UBYTE *FromDaten, *FromTempAlloc = 0;
  193.         WORD FromLaenge;
  194.         LONG FromWert;
  195.         BOOL UseFromWert = FALSE;
  196.         BOOL Valid = TRUE;
  197.  
  198.         switch( ClipConvFrom )
  199.         {
  200.             case CM_RAW:
  201.             case CM_TEXT:
  202.                 {
  203.                     FromLaenge = Laenge;
  204.  
  205.                     if( !Convert )
  206.                         if( FromLaenge > 256 )
  207.                             FromLaenge = 256;
  208.  
  209.                     FromDaten = String;
  210.  
  211.                     if( SetClipConvData( FromDaten, FromLaenge, TRUE, ClipConvFrom == CM_RAW, FALSE ))
  212.                         Error = TRUE;
  213.                 }
  214.  
  215.                 break;
  216.  
  217.             case CM_BIN:
  218.                 {
  219.                     UBYTE *ptr = String;
  220.                     ULONG StellenZahl = 0;
  221.  
  222.                     while( ptr < String + Laenge )
  223.                         if(( *ptr != ' ' ) && ( *ptr != '0' ) && ( *ptr != '1' ))
  224.                         {
  225.                             Valid = FALSE;
  226.                             break;
  227.                         }
  228.                         else
  229.                         {
  230.                             if( *ptr != ' ' )
  231.                                 StellenZahl++;
  232.     
  233.                             ptr++;
  234.                         }
  235.     
  236.                     if( Valid && StellenZahl )
  237.                     {
  238.                         FromLaenge = ( StellenZahl + 7 ) / 8;
  239.     
  240.                         if( FromTempAlloc = AllocVec( FromLaenge, MEMF_ANY ))
  241.                         {
  242.                             int k, Bits;
  243.                             UBYTE Aktu;
  244.  
  245.                             ptr = String;
  246.     
  247.                             Bits = 8 - ( long )( StellenZahl % 8 );
  248.  
  249.                             for( k = 0; k < FromLaenge; k++ )
  250.                             {
  251.                                 Aktu = 0;
  252.  
  253.                                 while( Bits != 8 )
  254.                                 {
  255.                                     if( *ptr != ' ' )
  256.                                     {
  257.                                         Aktu = ( Aktu << 1L ) + *ptr - '0';
  258.                                         Bits++;
  259.                                     }
  260.  
  261.                                     *ptr++;
  262.                                 }
  263.  
  264.                                 FromTempAlloc[ k ] = Aktu;
  265.  
  266.                                 Bits = 0;
  267.                             }
  268.  
  269.                             FromDaten = FromTempAlloc;
  270.  
  271.                             {
  272.                                 UBYTE *ptr;
  273.  
  274.                                 if( ptr = AllocVec( Laenge + 1, MEMF_ANY ))
  275.                                 {
  276.                                     strncpy( ptr, String, Laenge );
  277.                                     ptr[ Laenge ] = 0;
  278.  
  279.                                     SetClipConvFromGadget( ptr );
  280.                                 }
  281.                                 else
  282.                                 {
  283.                                     SetClipConvFromGadget( GetStr( MSG_INFO_GLOBAL_CANTALLOCSOMEMEM ));
  284.                                     SetClipConvToGadget( "" );
  285.                                     Error = TRUE;
  286.                                 }
  287.                             }
  288.                         }
  289.                         else
  290.                         {
  291.                             Error = TRUE;
  292.                             SetClipConvFromGadget( GetStr( MSG_INFO_GLOBAL_CANTALLOCSOMEMEM ));
  293.                             SetClipConvToGadget( "" );
  294.                         }
  295.                     }
  296.                     else
  297.                     {
  298.                         Error = TRUE;
  299.                         SetClipConvFromGadget( GetStr( MSG_INFO_CLIPCONV_NOTVALID ));
  300.                         SetClipConvToGadget( "" );
  301.                     }
  302.                 }
  303.                 break;
  304.  
  305.             case CM_DEC:
  306.             case CM_OCT:
  307.                 {
  308.                     if( ClipConvFrom == CM_DEC )
  309.                         Valid = IsDecString( String, Laenge );
  310.                     else
  311.                         Valid = IsOctString( String, Laenge );
  312.  
  313.                     if( Valid )
  314.                     {
  315.                         UBYTE Buffer[ 13 ];
  316.                         UBYTE *ptr;
  317.  
  318.                         if( ptr = AllocVec( Laenge + 1, MEMF_ANY ))
  319.                         {
  320.                             strncpy( ptr, String, Laenge );
  321.                             ptr[ Laenge ] = 0;
  322.  
  323.                             if( ClipConvFrom == CM_DEC )
  324.                             {
  325.                                 stcd_l( ptr, &FromWert );
  326.                                 stcl_d( Buffer, FromWert );
  327.                             }
  328.                             else
  329.                             {
  330.                                 stco_l( ptr, &FromWert );
  331.                                 stcl_o( Buffer, FromWert );
  332.                             }
  333.  
  334.                             SetClipConvFromGadget( Buffer );
  335.                             UseFromWert = TRUE;
  336.  
  337.                             FreeVec( ptr );
  338.                         }
  339.                         else
  340.                         {
  341.                             SetClipConvFromGadget( GetStr( MSG_INFO_GLOBAL_CANTALLOCSOMEMEM ));
  342.                             SetClipConvToGadget( "" );
  343.                             Error = TRUE;
  344.                         }
  345.                     }
  346.                     else
  347.                     {
  348.                         Error = TRUE;
  349.                         SetClipConvFromGadget( GetStr( MSG_INFO_CLIPCONV_NOTVALID ));
  350.                         SetClipConvToGadget( "" );
  351.                     }
  352.                 }
  353.                 break;
  354.  
  355.             case CM_HEX:
  356.                 {
  357.                     UBYTE *ptr = String;
  358.                     ULONG StellenZahl = 0;
  359.  
  360.                     while( ptr < String + Laenge )
  361.                         if(( *ptr != ' ' ) && ( !isxdigit( *ptr )))
  362.                         {
  363.                             Valid = FALSE;
  364.                             break;
  365.                         }
  366.                         else
  367.                         {
  368.                             ptr++;
  369.  
  370.                             if( *ptr != ' ' )
  371.                                 StellenZahl++;
  372.                         }
  373.     
  374.                     if( Valid && StellenZahl )
  375.                     {
  376.                         FromLaenge = ( StellenZahl + 1 ) / 2;
  377.     
  378.                         if( FromTempAlloc = AllocVec( FromLaenge, MEMF_ANY ))
  379.                         {
  380.                             int k, Bits;
  381.                             UBYTE Aktu;
  382.  
  383.                             ptr = String;
  384.  
  385.                             Bits = 2 - ( long )( StellenZahl % 2 );
  386.                             if( Bits == 2 ) Bits = 0;
  387.  
  388.                             for( k = 0; k < FromLaenge; k++ )
  389.                             {
  390.                                 Aktu = 0;
  391.  
  392.                                 while( Bits != 2 )
  393.                                 {
  394.                                     if( *ptr != ' ' )
  395.                                     {
  396.                                         if( isdigit( *ptr ))
  397.                                             Aktu = ( Aktu << 4L ) + *ptr - '0';
  398.                                         else
  399.                                             Aktu = ( Aktu << 4L ) + ( ToUpper( *ptr ) - 'A' ) + 0xa;
  400.  
  401.                                         Bits++;
  402.                                     }
  403.  
  404.                                     *ptr++;
  405.                                 }
  406.  
  407.                                 FromTempAlloc[ k ] = Aktu;
  408.  
  409.                                 Bits = 0;
  410.                             }
  411.  
  412.                             FromDaten = FromTempAlloc;
  413.  
  414.                             {
  415.                                 UBYTE *ptr;
  416.  
  417.                                 if( ptr = AllocVec( Laenge + 1, MEMF_ANY ))
  418.                                 {
  419.                                     strncpy( ptr, String, Laenge );
  420.                                     ptr[ Laenge ] = 0;
  421.  
  422.                                     SetClipConvFromGadget( ptr );
  423.                                 }
  424.                                 else
  425.                                 {
  426.                                     SetClipConvFromGadget( GetStr( MSG_INFO_GLOBAL_CANTALLOCSOMEMEM ));
  427.                                     SetClipConvToGadget( "" );
  428.                                     Error = TRUE;
  429.                                 }
  430.                             }
  431.                         }
  432.                         else
  433.                         {
  434.                             Error = TRUE;
  435.                             SetClipConvFromGadget( GetStr( MSG_INFO_GLOBAL_CANTALLOCSOMEMEM ));
  436.                             SetClipConvToGadget( "" );
  437.                         }
  438.                     }
  439.                     else
  440.                     {
  441.                         Error = TRUE;
  442.                         SetClipConvFromGadget( GetStr( MSG_INFO_CLIPCONV_NOTVALID ));
  443.                         SetClipConvToGadget( "" );
  444.                     }
  445.                 }
  446.  
  447.                 break;
  448.         }
  449.  
  450.     /* FromDaten | FromWert enthält jetzt die Daten */
  451.     /* FromLaenge die Laenge der FromDaten */
  452.  
  453.         if( Valid && ( !Error ))
  454.         {
  455.             switch( ClipConvTo )
  456.             {
  457.                 case CM_OCT:
  458.                 case CM_DEC:
  459.                     if(( !UseFromWert ) && ( FromLaenge <= 4 ))
  460.                     {
  461.                         FromWert = FromDaten[0];
  462.                         if( FromLaenge >= 2 ) FromWert = ( FromWert << 8 ) + FromDaten[1];
  463.                         if( FromLaenge >= 3 ) FromWert = ( FromWert << 8 ) + FromDaten[2];
  464.                         if( FromLaenge >= 4 ) FromWert = ( FromWert << 8 ) + FromDaten[3];
  465.         
  466.                         UseFromWert = TRUE;
  467.                     }
  468.  
  469.                     if( UseFromWert )
  470.                     {
  471.                         UBYTE Buffer[ 13 ];
  472.  
  473.                         switch( ClipConvTo )
  474.                         {
  475.                             case CM_OCT:
  476.                                 stcl_o( Buffer, FromWert );
  477.                                 break;
  478.                             case CM_DEC:
  479.                                 stcl_d( Buffer, FromWert );
  480.                                 break;
  481.                         }
  482.  
  483.                         SetClipConvToGadget( Buffer );
  484.  
  485.                         if( Convert )
  486.                             SaveClip( Buffer, strlen( Buffer ));
  487.                     }
  488.                     else
  489.                         SetClipConvToGadget( GetStr( MSG_INFO_CLIPCONV_NOTCONVERTIBLE ));
  490.                     
  491.                     break;
  492.                 case CM_BIN:
  493.                 case CM_HEX:
  494.                 case CM_RAW:
  495.                 case CM_TEXT:
  496.                     if( UseFromWert )
  497.                     {
  498.                         if( FromWert & 0xffff0000 )
  499.                             if( FromWert & 0xff000000 )
  500.                                 FromLaenge = 4;
  501.                             else
  502.                                 FromLaenge = 3;
  503.                         else
  504.                             if( FromWert & 0xff00 )
  505.                                 FromLaenge = 2;
  506.                             else
  507.                                 FromLaenge = 1;
  508.  
  509.                         if( FromTempAlloc = AllocVec( FromLaenge, MEMF_ANY ))
  510.                         {
  511.                             int k;
  512.  
  513.                             FromDaten = FromTempAlloc;
  514.  
  515.                             for( k = 0; k < FromLaenge; k++ )
  516.                             {
  517.                                 FromTempAlloc[ FromLaenge - k - 1 ] = FromWert & 0xff;
  518.                                 FromWert = FromWert >> 8L;
  519.                             }
  520.  
  521. /*                            UseFromWert = FALSE;*/
  522.                         }
  523.                         else
  524.                             SetClipConvToGadget( GetStr( MSG_INFO_GLOBAL_CANTALLOCSOMEMEM ));
  525.                     }
  526.  
  527.                     if( ClipConvTo == CM_BIN )
  528.                         SetClipConvDataBin( FromDaten, FromLaenge, FALSE, Convert );
  529.                     else
  530.                     {
  531.                         if( ClipConvTo == CM_HEX )
  532.                             SetClipConvData( FromDaten, FromLaenge, FALSE, ClipConvTo != CM_TEXT, Convert );
  533.                         else
  534.                         {
  535.                             SetClipConvData( FromDaten, FromLaenge, FALSE, ClipConvTo != CM_TEXT, FALSE );
  536.  
  537.                             if( Convert )
  538.                                 SaveClip( FromDaten, FromLaenge );
  539.                         }
  540.                     }
  541.                     break;
  542.             }
  543.         }
  544.  
  545.         if( FromTempAlloc ) FreeVec( FromTempAlloc );
  546.     }
  547.     else
  548.     {
  549.         SetClipConvFromGadget( GetStr( MSG_INFO_CLIPCONV_EMPTY ));
  550.         SetClipConvToGadget( "" );
  551.     }
  552.  
  553.     if( String ) FreeMem( String, Laenge );
  554. }
  555.  
  556. static void UpdateClipConvSignal( void )
  557. {
  558.     UpdateClipConv( FALSE );
  559. }
  560.  
  561. static ULONG __saveds __asm ClipHookFunc(    register __a0 struct Hook *hook,
  562.                                                         register __a2 APTR Obj,
  563.                                                         register __a1 APTR Msg    )
  564. {
  565.     Signal( hook->h_Data, SIGBREAKF_CTRL_E );
  566.    return(0);
  567. }
  568.  
  569. static struct Hook ClipHook =
  570. {
  571.     0, 0, (ULONG (*)()) ClipHookFunc, 0, 0
  572. };
  573.  
  574. static void SetClipConvFrom( UWORD From )
  575. {
  576.     GT_SetGadgetAttrs( ClipConvGadgets[ 0 ] , ClipConvWnd, NULL,
  577.                                 GTCY_Active, From,
  578.                                 TAG_DONE);
  579.     ClipConvFrom = From;
  580.  
  581.     UpdateClipConv( FALSE );
  582. }
  583.  
  584. static void SetClipConvTo( UWORD To )
  585. {
  586.     GT_SetGadgetAttrs( ClipConvGadgets[ 1 ] , ClipConvWnd, NULL,
  587.                                 GTCY_Active, To,
  588.                                 TAG_DONE);
  589.     ClipConvTo = To;
  590.  
  591.     UpdateClipConv( FALSE );
  592. }
  593.  
  594.  
  595. static MakeClipConvGadgets( UWORD Breite )
  596. {
  597.     struct NewGadget ng;
  598.     struct Gadget *g;
  599.     static struct TagItem CycleTags[3] =
  600.     {GTCY_Labels, 0, GTCY_Active, 0, TAG_DONE};
  601.     UWORD CycleWidth = 0;
  602.  
  603.     Breite -= 2 * BORDERX + 2 * BEVELX + 2 * INNERX;
  604.  
  605.  
  606.     if( ClipConvGList )
  607.     {
  608.         RemoveGList( ClipConvWnd, ClipConvGList, -1 );
  609.  
  610.         FreeGadgets( ClipConvGList );
  611.         ClipConvGList = NULL;
  612.     }
  613.  
  614.     {
  615.         UWORD DummyBreite;
  616.         char **Inhalt;
  617.  
  618.         Inhalt = CCModeNames;
  619.  
  620.         while( *Inhalt )
  621.         {
  622.             DummyBreite = MyTextLength( &ClipConvWI->RP, *Inhalt++ ) + 30;
  623.  
  624.             if( CycleWidth < DummyBreite )
  625.                 CycleWidth = DummyBreite;
  626.         }
  627.     }
  628.  
  629.     if(! (g = CreateContext(&ClipConvGList)))
  630.         return(1L);
  631.  
  632.     ng.ng_VisualInfo = VisualInfo;
  633.     ng.ng_TextAttr = &ClipConvWI->TA;
  634.     ng.ng_Flags = PLACETEXT_LEFT;
  635.     ng.ng_TopEdge = Scr->RastPort.TxHeight + Scr->WBorTop + 1 + BEVELY + INNERY + BORDERY;
  636.     ng.ng_GadgetID = 0;
  637.     ng.ng_LeftEdge = Scr->WBorLeft + BORDERX + BEVELX + BUTTONX;
  638.     ng.ng_Width = CycleWidth;
  639.     ng.ng_TopEdge = Scr->RastPort.TxHeight + Scr->WBorTop + 1 + BORDERY + BEVELY + BUTTONY;
  640.  
  641.  
  642.     ng.ng_GadgetText = 0;
  643.     ng.ng_Height = ClipConvWI->TF->tf_YSize + 6;
  644.  
  645.     CycleTags[0].ti_Data = ( ULONG )CCModeNames;
  646.     CycleTags[1].ti_Data = ClipConvFrom;
  647.  
  648.     ClipConvGadgets[0] = g = CreateGadgetA( CYCLE_KIND, g, &ng, CycleTags);
  649.     ng.ng_GadgetID++;
  650.  
  651.  
  652.     CycleTags[1].ti_Data = ClipConvTo;
  653.     ng.ng_TopEdge += ng.ng_Height + INNERGADGETY;
  654.     ClipConvGadgets[1] = g = CreateGadgetA( CYCLE_KIND, g, &ng, CycleTags);
  655.     ng.ng_GadgetID++;
  656.  
  657.  
  658.     ng.ng_Width = Breite;
  659.     ng.ng_Flags = PLACETEXT_IN;
  660.     ng.ng_GadgetText = GetStr( MSG_GADGET_CLIPCONV_CONVERT );
  661.     ng.ng_TopEdge += ng.ng_Height + INNERGADGETY;
  662.     ClipConvGadgets[2] = g = CreateGadgetA( BUTTON_KIND, g, &ng, NULL );
  663.     ng.ng_GadgetID++;
  664.  
  665.  
  666.     ng.ng_Width = Breite - CycleWidth - INNERGADGETY;
  667.     ng.ng_LeftEdge += CycleWidth + INNERGADGETY;
  668.     ng.ng_GadgetText = 0;
  669.     ng.ng_TopEdge = Scr->RastPort.TxHeight + Scr->WBorTop + 1 + BEVELY + INNERY + BORDERY;
  670.     ClipConvGadgets[3] = g = CreateGadget( TEXT_KIND, g, &ng, GTTX_CopyText, TRUE, GTTX_Border, TRUE, TAG_DONE );
  671.     ng.ng_GadgetID++;
  672.  
  673.     ng.ng_TopEdge += ng.ng_Height + INNERGADGETY;
  674.     ClipConvGadgets[4] = g = CreateGadget( TEXT_KIND, g, &ng, GTTX_CopyText, TRUE, GTTX_Border, TRUE, TAG_DONE );
  675.  
  676.     if(!g) return(2L);
  677.  
  678.     if( ClipConvWnd )
  679.     {
  680.         SetzeMuster( ClipConvWnd );
  681.  
  682.         MyFilledDrawBevelBox(ClipConvWnd->RPort,    ClipConvWnd->BorderLeft + BORDERX,
  683.                                                             ClipConvWnd->BorderTop + BORDERY,
  684.                                                             ClipConvWnd->Width - ClipConvWnd->BorderRight - ClipConvWnd->BorderLeft - BORDERX * 2,
  685.                                                             ClipConvWnd->Height - ClipConvWnd->BorderBottom - ClipConvWnd->BorderTop - 2 * BORDERY,
  686.                                                             TRUE);
  687.     
  688.         AddGList( ClipConvWnd, ClipConvGList, -1, -1, 0);
  689.  
  690.         RefreshGadgets(ClipConvGList, ClipConvWnd, 0);
  691.         GT_RefreshWindow( ClipConvWnd, NULL );
  692.  
  693.         UpdateClipConv( FALSE );
  694.     }
  695. }
  696.  
  697. static void DoClipConvWndMsg( void )
  698. {
  699.     BOOL CloseMe = FALSE;
  700.     struct IntuiMessage    *m, Msg;
  701.     struct Gadget *gad;
  702.  
  703.     while( m = GT_GetIMsg( ClipConvWnd->UserPort ))
  704.     {
  705.         CopyMem((char *)m, (char *)&Msg, (long)sizeof(struct IntuiMessage));
  706.  
  707.         GT_ReplyIMsg(m);
  708.  
  709.         gad = (struct Gadget *) Msg.IAddress;
  710.  
  711.         switch( Msg.Class )
  712.         {
  713.             case    IDCMP_NEWSIZE:
  714.                 {
  715.                     MakeClipConvGadgets( ClipConvWnd->Width - ClipConvWnd->BorderLeft - ClipConvWnd->BorderRight );
  716.     
  717.                     RefreshWindowFrame( ClipConvWnd );
  718.                 }
  719.                 break;
  720.  
  721.             case    IDCMP_RAWKEY:
  722.                 switch( Msg.Code )
  723.                 {
  724.                     case CURSORUP:
  725.                         SetClipConvFrom(( ClipConvFrom + 1 ) % 6);
  726.                         break;
  727.                     case CURSORLEFT:
  728.                         SetClipConvTo(( ClipConvTo + 1 ) % 6);
  729.                         break;
  730.  
  731.                     case CURSORDOWN:
  732.                         SetClipConvFrom(( ClipConvFrom + 5 ) % 6);
  733.                         break;
  734.                     case CURSORRIGHT:
  735.                         SetClipConvTo(( ClipConvTo + 5 ) % 6);
  736.                         break;
  737.                         break;
  738.                 }
  739.                 break;
  740.  
  741.             case    IDCMP_VANILLAKEY:
  742.                 if( Msg.Code == 27 )
  743.                     CloseMe = TRUE;
  744.                 else
  745.                 if( Msg.Code == 13 )
  746.                     UpdateClipConv( TRUE );
  747.                 else
  748.                 if( Msg.Code == ' ' )
  749.                     ActivateWindow( AktuDI->Wnd );
  750.                     break;
  751.                     
  752.                 break;
  753.  
  754.             case    IDCMP_CLOSEWINDOW:
  755.                 CloseMe = TRUE;
  756.                 break;
  757.  
  758.             case    IDCMP_GADGETUP:
  759.                 switch( gad->GadgetID )
  760.                 {    
  761.                     case 0:
  762.                         SetClipConvFrom( Msg.Code );
  763.                         break;
  764.  
  765.                     case 1:
  766.                         SetClipConvTo( Msg.Code );
  767.                         break;
  768.  
  769.                     case 2:
  770.                         UpdateClipConv( TRUE );
  771.                         break;
  772.                 }
  773.         }
  774.     }
  775.  
  776.     if( CloseMe )
  777.         CloseClipConv();
  778. }
  779.  
  780. static struct IOClipReq *ClipboardIO;
  781. static struct MsgPort *ClipboardMsgPort;
  782.  
  783. BOOL OpenClipConv( void )
  784. {
  785.     if( ClipConvWnd )
  786.     {
  787.         ActivateWindow( ClipConvWnd );
  788.         return( TRUE );
  789.     }
  790.  
  791.     if( ClipConvTop == -1 ) ClipConvTop = AktuDI->Wnd->TopEdge;
  792.     if( ClipConvLeft == -1 ) ClipConvLeft = AktuDI->Wnd->LeftEdge + AktuDI->Wnd->Width;
  793.  
  794.         /* Lokalisieren des Cyclegadgets */
  795.  
  796.     if( !Localized )
  797.     {
  798.         char **s;
  799.  
  800.         Localized = TRUE;
  801.         s = CCModeNames;
  802.  
  803.         while( *s )
  804.         {
  805.             *s = GetStr( *s );
  806.             s++;
  807.         }
  808.     }
  809.  
  810.     {
  811.         BOOL Success = FALSE;
  812.  
  813.         if( ClipboardMsgPort = CreatePort(0L,0L) )
  814.         {
  815.             if( ClipboardIO = (struct IOClipReq *)    CreateExtIO(ClipboardMsgPort,sizeof(struct IOClipReq)))
  816.             {
  817.                 if((!OpenDevice("clipboard.device", GetClipboardUnit(), ( struct IORequest * )ClipboardIO, 0)))
  818.                 {
  819.                     Success = TRUE;
  820.                 }
  821.             }
  822.         }
  823.  
  824.         if( !Success )
  825.         {
  826.             if( ClipboardIO ) DeleteExtIO(( struct IORequest * )ClipboardIO );
  827.             if( ClipboardMsgPort ) DeletePort( ClipboardMsgPort );
  828.             return( FALSE );
  829.         }
  830.         else
  831.         {
  832.             ClipHook.h_Data = FindTask( NULL );
  833.  
  834.             MyAddSignal( SIGBREAKF_CTRL_E, &UpdateClipConvSignal );
  835.  
  836.             ClipboardIO->io_Data = ( char * ) &ClipHook;
  837.             ClipboardIO->io_Length = 1;
  838.             ClipboardIO->io_Command = CBD_CHANGEHOOK;
  839.  
  840.             DoIO(( struct IORequest * ) ClipboardIO );
  841.         }
  842.     }
  843.  
  844.  
  845.     if( ClipConvWI = NewCalcSetup( Scr ))
  846.     {
  847.         UWORD ClipConvHeight;
  848.         UWORD MinWidth = 0;
  849.         UWORD DummyBreite;
  850.         char **Inhalt;
  851.  
  852.         Inhalt = CCModeNames;
  853.  
  854.         while( *Inhalt )
  855.         {
  856.             DummyBreite = MyTextLength( &ClipConvWI->RP, *Inhalt++ ) + 30;
  857.  
  858.             if( MinWidth < DummyBreite )
  859.                 MinWidth = DummyBreite;
  860.         }
  861.  
  862.         MinWidth += 8 * ClipConvWI->MaxHexWidth + 8 + INNERGADGETY;
  863.  
  864.         DummyBreite = MyTextLength( &ClipConvWI->RP, GetStr( MSG_GADGET_CLIPCONV_CONVERT )) + 16;
  865.  
  866.         if( MinWidth < DummyBreite )
  867.             MinWidth = DummyBreite;
  868.  
  869.         MinWidth += 2 * BORDERX + 2 * BEVELX + 2 * INNERX;
  870.  
  871.         if(( ClipConvWidth == -1 ) || ( ClipConvWidth < MinWidth ))
  872.             ClipConvWidth = MinWidth;
  873.  
  874.         ClipConvHeight = (ClipConvWI->TF->tf_YSize + 6) * 3 + INNERGADGETY * 2 + 2 * BORDERY + 2 * BEVELY + 2 * INNERY;
  875.  
  876. #ifndef WFLG_SIZEBOTTOM
  877. #define WFLG_SIZEBOTTOM WFLG_SIZEBBOTTOM
  878. #endif
  879.  
  880.         if ( ! ( ClipConvWnd = OpenWindowTags( NULL,
  881.             WA_Left,    ClipConvLeft,
  882.             WA_Top,        ClipConvTop,
  883.             WA_InnerWidth,    ClipConvWidth,
  884.             WA_InnerHeight,    ClipConvHeight,
  885.             WA_MaxWidth,    -1,
  886.             WA_MinWidth,    MinWidth,
  887.             WA_IDCMP,    BUTTONIDCMP | INTEGERIDCMP | TEXTIDCMP | IDCMP_CLOSEWINDOW | IDCMP_RAWKEY | IDCMP_VANILLAKEY | IDCMP_REFRESHWINDOW | IDCMP_NEWSIZE,
  888.             WA_Flags,    WFLG_SIZEGADGET | WFLG_SIZEBOTTOM | WFLG_DRAGBAR | WFLG_DEPTHGADGET | WFLG_CLOSEGADGET | WFLG_SMART_REFRESH | WFLG_ACTIVATE | WFLG_RMBTRAP,
  889.             WA_Title,    GetStr( MSG_WINDOWTITLE_CLIPCONV ),
  890.             WA_ScreenTitle,    "FileX '94",
  891.             WA_PubScreen,    Scr,
  892.             TAG_DONE )))
  893.             return(3L);
  894.  
  895.         MakeClipConvGadgets( ClipConvWidth );
  896.  
  897.         mainflags |= MF_CLIPCONV;
  898.  
  899.         MyAddSignal( 1L << ClipConvWnd->UserPort->mp_SigBit, &DoClipConvWndMsg );
  900.     }
  901. }
  902.  
  903. void CloseClipConv( void )
  904. {
  905.     MyRemoveSignal( 1L << ClipConvWnd->UserPort->mp_SigBit );
  906.     MyRemoveSignal( SIGBREAKF_CTRL_E );
  907.  
  908.     mainflags &= ~MF_CLIPCONV;
  909.  
  910.     if( ClipboardIO )
  911.     {
  912.         ClipboardIO->io_Data = ( char * ) &ClipHook;
  913.         ClipboardIO->io_Length = 0;
  914.         ClipboardIO->io_Command = CBD_CHANGEHOOK;
  915.  
  916.         DoIO(( struct IORequest * ) ClipboardIO );
  917.  
  918.         CloseDevice(( struct IORequest * ) ClipboardIO );
  919.         DeleteExtIO(( struct IORequest * ) ClipboardIO );
  920.     }
  921.     if( ClipboardMsgPort ) DeletePort( ClipboardMsgPort );
  922.  
  923.     if( ClipConvWnd )
  924.     {
  925.         ClipConvLeft = ClipConvWnd->LeftEdge;
  926.         ClipConvTop = ClipConvWnd->TopEdge;
  927.         ClipConvWidth = ClipConvWnd->Width - ClipConvWnd->BorderLeft - ClipConvWnd->BorderRight;
  928.  
  929.         CloseWindow( ClipConvWnd );
  930.         ClipConvWnd = NULL;
  931.     }
  932.  
  933.     if( FromStringDisplay )
  934.     {
  935.         FreeVec( FromStringDisplay );
  936.         FromStringDisplay = NULL;
  937.     }
  938.  
  939.     if( ToStringDisplay )
  940.     {
  941.         FreeVec( ToStringDisplay );
  942.         ToStringDisplay = NULL;
  943.     }
  944.  
  945.     if( ClipConvGList )
  946.     {
  947.         FreeGadgets( ClipConvGList );
  948.         ClipConvGList = NULL;
  949.     }
  950.  
  951.     if( ClipConvWI )
  952.     {
  953.         NewCalcCleanup( ClipConvWI );
  954.         ClipConvWI = NULL;
  955.     }
  956. }
  957.